package demoLambda;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/*
**@Description:Lambda
 */
//当一个接口中只有一个抽象方法的时候就叫做函数式接口
@FunctionalInterface//帮助进行校验是不是函数式接口
interface NoParameterNoReturn{
    void test();
//    void test1();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}
public class Test {
    public static void main(String[] args) {
        //能够于lambda表达式对接的接口方法
        //Map的forEach
        Map<String, Integer> map = new HashMap<>();
        map.put("abc",10);
        map.put("hello",3);
        map.put("world",6);
        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key:"+ s + " " +"value:" + integer);
            }
        });
        System.out.println("======");
        //使用lambda表达式
        map.forEach((key,val)-> System.out.println("key:" + key + " " + "value:" + val));
    }
    public static void main6(String[] args) {
        //能够于lambda表达式对接的接口方法
        //1.Collection接口的forEach
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("abcd");
        arrayList.add("hello");
        arrayList.add("efds");
        //遍历ArrayList
        arrayList.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println("======");
        //使用Lambda表达式
        arrayList.forEach(s-> System.out.println(s));
        //2.List接口的sort方法
//        arrayList.sort(new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.compareTo(o2);
//            }
//        });
        //使用lambda表达式
        arrayList.sort((o1,o2)->o1.compareTo(o2));
        arrayList.forEach(s-> System.out.println(s));

    }
    public static void main5(String[] args) {
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });
        PriorityQueue<Integer> maxHeap1 = new PriorityQueue<>((x,y)->{return x.compareTo(y);});
        PriorityQueue<Integer> maxHeap2 = new PriorityQueue<>((x,y)->x.compareTo(y));

    }
    public static void main4(String[] args) {
        int a = 10;
//        a = 100;//a的值改变了--》此时就不能捕获a
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                //此时捕获的变量一定是一直没有修改的，或者是一个常量
                System.out.println("a="+a);//实现了变量a的捕获
            }
        };
        NoParameterNoReturn noParameterNoReturn1 = ()-> {System.out.println("a="+a);};//lambda也能够实现变量的捕获
        noParameterNoReturn1.test();
    }
    //有返回值的接口方法
    public static void main3(String[] args) {
        //有返回值无参数
//        NoParameterReturn noParameterReturn = ()->{return 10;};//下面为其简写
        NoParameterReturn noParameterReturn = ()->10;
        int ret = noParameterReturn.test();//返回值进行接收
        System.out.println(ret);
        System.out.println("======");
        //有返回值有一个参数
//        OneParameterReturn oneParameterReturn = (x)->{return x*2;};
        OneParameterReturn oneParameterReturn = x->x*2;
        System.out.println(oneParameterReturn.test(12));
        System.out.println("======");
//        MoreParameterReturn moreParameterReturn = (x,y)->{return x*y;};
        MoreParameterReturn moreParameterReturn = (x,y)->x*y;
        System.out.println(moreParameterReturn.test(10, 20));
    }
    //有参数无返回值
    public static void main2(String[] args) {
        OneParameterNoReturn oneParameterNoReturn = (x)-> System.out.println(x);
        oneParameterNoReturn.test(10);
        System.out.println("==========");
        MoreParameterNoReturn moreParameterNoReturn = (x,y)-> System.out.println(x+y);
        moreParameterNoReturn.test(10,20);
        System.out.println("==========");

    }
    public static void main1(String[] args) {
        //利用匿名内部内实现接口里面的方法
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("hello");
            }
        };
        noParameterNoReturn.test();
        //使用lambda表达式实现
        NoParameterNoReturn noParameterNoReturn1 = ()-> {System.out.println("hello");};
        noParameterNoReturn1.test();
    }
}
